home *** CD-ROM | disk | FTP | other *** search
/ Freelog 125 / Freelog_MarsAvril2015_No125.iso / Musique / Quod Libet / quodlibet-3.3.0-installer.exe / bin / socket.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2014-12-31  |  16KB  |  542 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.7)
  3.  
  4. """This module provides socket operations and some related functions.
  5. On Unix, it supports IP (Internet Protocol) and Unix domain sockets.
  6. On other systems, it only supports IP. Functions specific for a
  7. socket are available as methods of the socket object.
  8.  
  9. Functions:
  10.  
  11. socket() -- create a new socket object
  12. socketpair() -- create a pair of new socket objects [*]
  13. fromfd() -- create a socket object from an open file descriptor [*]
  14. gethostname() -- return the current hostname
  15. gethostbyname() -- map a hostname to its IP number
  16. gethostbyaddr() -- map an IP number or hostname to DNS info
  17. getservbyname() -- map a service name and a protocol name to a port number
  18. getprotobyname() -- map a protocol name (e.g. 'tcp') to a number
  19. ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order
  20. htons(), htonl() -- convert 16, 32 bit int from host to network byte order
  21. inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format
  22. inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89)
  23. ssl() -- secure socket layer support (only available if configured)
  24. socket.getdefaulttimeout() -- get the default timeout value
  25. socket.setdefaulttimeout() -- set the default timeout value
  26. create_connection() -- connects to an address, with an optional timeout and
  27.                        optional source address.
  28.  
  29.  [*] not available on all platforms!
  30.  
  31. Special objects:
  32.  
  33. SocketType -- type object for socket objects
  34. error -- exception raised for I/O errors
  35. has_ipv6 -- boolean value indicating if IPv6 is supported
  36.  
  37. Integer constants:
  38.  
  39. AF_INET, AF_UNIX -- socket domains (first argument to socket() call)
  40. SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)
  41.  
  42. Many other constants may be defined; these may be used in calls to
  43. the setsockopt() and getsockopt() methods.
  44. """
  45. import _socket
  46. from _socket import *
  47. from functools import partial
  48. from types import MethodType
  49.  
  50. try:
  51.     import _ssl
  52. except ImportError:
  53.     pass
  54.  
  55.  
  56. def ssl(sock, keyfile = None, certfile = None):
  57.     import ssl as _realssl
  58.     warnings.warn('socket.ssl() is deprecated.  Use ssl.wrap_socket() instead.', DeprecationWarning, stacklevel = 2)
  59.     return _realssl.sslwrap_simple(sock, keyfile, certfile)
  60.  
  61. from _ssl import SSLError as sslerror
  62. from _ssl import RAND_add, RAND_egd, RAND_status, SSL_ERROR_ZERO_RETURN, SSL_ERROR_WANT_READ, SSL_ERROR_WANT_WRITE, SSL_ERROR_WANT_X509_LOOKUP, SSL_ERROR_SYSCALL, SSL_ERROR_SSL, SSL_ERROR_WANT_CONNECT, SSL_ERROR_EOF, SSL_ERROR_INVALID_ERROR_CODE
  63. import os
  64. import sys
  65. import warnings
  66.  
  67. try:
  68.     from cStringIO import StringIO
  69. except ImportError:
  70.     from StringIO import StringIO
  71.  
  72.  
  73. try:
  74.     import errno
  75. except ImportError:
  76.     errno = None
  77.  
  78. EBADF = getattr(errno, 'EBADF', 9)
  79. EINTR = getattr(errno, 'EINTR', 4)
  80. __all__ = [
  81.     'getfqdn',
  82.     'create_connection']
  83. __all__.extend(os._get_exports_list(_socket))
  84. _realsocket = socket
  85. if sys.platform.lower().startswith('win'):
  86.     errorTab = { }
  87.     errorTab[10004] = 'The operation was interrupted.'
  88.     errorTab[10009] = 'A bad file handle was passed.'
  89.     errorTab[10013] = 'Permission denied.'
  90.     errorTab[10014] = 'A fault occurred on the network??'
  91.     errorTab[10022] = 'An invalid operation was attempted.'
  92.     errorTab[10035] = 'The socket operation would block'
  93.     errorTab[10036] = 'A blocking operation is already in progress.'
  94.     errorTab[10048] = 'The network address is in use.'
  95.     errorTab[10054] = 'The connection has been reset.'
  96.     errorTab[10058] = 'The network has been shut down.'
  97.     errorTab[10060] = 'The operation timed out.'
  98.     errorTab[10061] = 'Connection refused.'
  99.     errorTab[10063] = 'The name is too long.'
  100.     errorTab[10064] = 'The host is down.'
  101.     errorTab[10065] = 'The host is unreachable.'
  102.     __all__.append('errorTab')
  103.  
  104. def getfqdn(name = ''):
  105.     '''Get fully qualified domain name from name.
  106.  
  107.     An empty argument is interpreted as meaning the local host.
  108.  
  109.     First the hostname returned by gethostbyaddr() is checked, then
  110.     possibly existing aliases. In case no FQDN is available, hostname
  111.     from gethostname() is returned.
  112.     '''
  113.     name = name.strip()
  114.     if not name or name == '0.0.0.0':
  115.         name = gethostname()
  116.     
  117.     try:
  118.         (hostname, aliases, ipaddrs) = gethostbyaddr(name)
  119.     except error:
  120.         pass
  121.  
  122.     aliases.insert(0, hostname)
  123.     for name in aliases:
  124.         if '.' in name:
  125.             break
  126.             continue
  127.         name = hostname
  128.         return name
  129.  
  130. _socketmethods = ('bind', 'connect', 'connect_ex', 'fileno', 'listen', 'getpeername', 'getsockname', 'getsockopt', 'setsockopt', 'sendall', 'setblocking', 'settimeout', 'gettimeout', 'shutdown')
  131. if os.name == 'nt':
  132.     _socketmethods = _socketmethods + ('ioctl',)
  133. if sys.platform == 'riscos':
  134.     _socketmethods = _socketmethods + ('sleeptaskw',)
  135. _delegate_methods = ('recv', 'recvfrom', 'recv_into', 'recvfrom_into', 'send', 'sendto')
  136.  
  137. class _closedsocket(object):
  138.     __slots__ = []
  139.     
  140.     def _dummy(*args):
  141.         raise error(EBADF, 'Bad file descriptor')
  142.  
  143.     send = recv = recv_into = sendto = recvfrom = recvfrom_into = _dummy
  144.     __getattr__ = _dummy
  145.  
  146.  
  147. class _socketobject(object):
  148.     __doc__ = _realsocket.__doc__
  149.     __slots__ = [
  150.         '_sock',
  151.         '__weakref__'] + list(_delegate_methods)
  152.     
  153.     def __init__(self, family = AF_INET, type = SOCK_STREAM, proto = 0, _sock = None):
  154.         if _sock is None:
  155.             _sock = _realsocket(family, type, proto)
  156.         self._sock = _sock
  157.         for method in _delegate_methods:
  158.             setattr(self, method, getattr(_sock, method))
  159.         
  160.  
  161.     
  162.     def close(self, _closedsocket = _closedsocket, _delegate_methods = _delegate_methods, setattr = setattr):
  163.         self._sock = _closedsocket()
  164.         dummy = self._sock._dummy
  165.         for method in _delegate_methods:
  166.             setattr(self, method, dummy)
  167.         
  168.  
  169.     close.__doc__ = _realsocket.close.__doc__
  170.     
  171.     def accept(self):
  172.         (sock, addr) = self._sock.accept()
  173.         return (_socketobject(_sock = sock), addr)
  174.  
  175.     accept.__doc__ = _realsocket.accept.__doc__
  176.     
  177.     def dup(self):
  178.         '''dup() -> socket object
  179.  
  180.         Return a new socket object connected to the same system resource.'''
  181.         return _socketobject(_sock = self._sock)
  182.  
  183.     
  184.     def makefile(self, mode = 'r', bufsize = -1):
  185.         '''makefile([mode[, bufsize]]) -> file object
  186.  
  187.         Return a regular file object corresponding to the socket.  The mode
  188.         and bufsize arguments are as for the built-in open() function.'''
  189.         return _fileobject(self._sock, mode, bufsize)
  190.  
  191.     family = property((lambda self: self._sock.family), doc = 'the socket family')
  192.     type = property((lambda self: self._sock.type), doc = 'the socket type')
  193.     proto = property((lambda self: self._sock.proto), doc = 'the socket protocol')
  194.  
  195.  
  196. def meth(name, self, *args):
  197.     return getattr(self._sock, name)(*args)
  198.  
  199. for _m in _socketmethods:
  200.     p = partial(meth, _m)
  201.     p.__name__ = _m
  202.     p.__doc__ = getattr(_realsocket, _m).__doc__
  203.     m = MethodType(p, None, _socketobject)
  204.     setattr(_socketobject, _m, m)
  205.  
  206. socket = SocketType = _socketobject
  207.  
  208. class _fileobject(object):
  209.     '''Faux file object attached to a socket object.'''
  210.     default_bufsize = 8192
  211.     name = '<socket>'
  212.     __slots__ = [
  213.         'mode',
  214.         'bufsize',
  215.         'softspace',
  216.         '_sock',
  217.         '_rbufsize',
  218.         '_wbufsize',
  219.         '_rbuf',
  220.         '_wbuf',
  221.         '_wbuf_len',
  222.         '_close']
  223.     
  224.     def __init__(self, sock, mode = 'rb', bufsize = -1, close = False):
  225.         self._sock = sock
  226.         self.mode = mode
  227.         if bufsize < 0:
  228.             bufsize = self.default_bufsize
  229.         self.bufsize = bufsize
  230.         self.softspace = False
  231.         if bufsize == 0:
  232.             self._rbufsize = 1
  233.         elif bufsize == 1:
  234.             self._rbufsize = self.default_bufsize
  235.         else:
  236.             self._rbufsize = bufsize
  237.         self._wbufsize = bufsize
  238.         self._rbuf = StringIO()
  239.         self._wbuf = []
  240.         self._wbuf_len = 0
  241.         self._close = close
  242.  
  243.     
  244.     def _getclosed(self):
  245.         return self._sock is None
  246.  
  247.     closed = property(_getclosed, doc = 'True if the file is closed')
  248.     
  249.     def close(self):
  250.         
  251.         try:
  252.             if self._sock:
  253.                 self.flush()
  254.         finally:
  255.             if self._close:
  256.                 self._sock.close()
  257.             self._sock = None
  258.  
  259.  
  260.     
  261.     def __del__(self):
  262.         
  263.         try:
  264.             self.close()
  265.         except:
  266.             pass
  267.  
  268.  
  269.     
  270.     def flush(self):
  271.         if self._wbuf:
  272.             data = ''.join(self._wbuf)
  273.             self._wbuf = []
  274.             self._wbuf_len = 0
  275.             buffer_size = max(self._rbufsize, self.default_bufsize)
  276.             data_size = len(data)
  277.             write_offset = 0
  278.             view = memoryview(data)
  279.             
  280.             try:
  281.                 while write_offset < data_size:
  282.                     self._sock.sendall(view[write_offset:write_offset + buffer_size])
  283.                     write_offset += buffer_size
  284.             finally:
  285.                 if write_offset < data_size:
  286.                     remainder = data[write_offset:]
  287.                     del view
  288.                     del data
  289.                     self._wbuf.append(remainder)
  290.                     self._wbuf_len = len(remainder)
  291.  
  292.  
  293.     
  294.     def fileno(self):
  295.         return self._sock.fileno()
  296.  
  297.     
  298.     def write(self, data):
  299.         data = str(data)
  300.         if not data:
  301.             return None
  302.         None._wbuf.append(data)
  303.         self._wbuf_len += len(data)
  304.         if not self._wbufsize == 0:
  305.             if (self._wbufsize == 1 or '\n' in data or self._wbufsize > 1) and self._wbuf_len >= self._wbufsize:
  306.                 self.flush()
  307.             return None
  308.  
  309.     
  310.     def writelines(self, list):
  311.         lines = filter(None, map(str, list))
  312.         self._wbuf_len += sum(map(len, lines))
  313.         self._wbuf.extend(lines)
  314.         if self._wbufsize <= 1 or self._wbuf_len >= self._wbufsize:
  315.             self.flush()
  316.  
  317.     
  318.     def read(self, size = -1):
  319.         rbufsize = max(self._rbufsize, self.default_bufsize)
  320.         buf = self._rbuf
  321.         buf.seek(0, 2)
  322.         if size < 0:
  323.             self._rbuf = StringIO()
  324.             while True:
  325.                 
  326.                 try:
  327.                     data = self._sock.recv(rbufsize)
  328.                 except error:
  329.                     e = None
  330.                     if e.args[0] == EINTR:
  331.                         continue
  332.                     raise 
  333.  
  334.                 if not data:
  335.                     break
  336.                 buf.write(data)
  337.             return buf.getvalue()
  338.         buf_len = None.tell()
  339.         if buf_len >= size:
  340.             buf.seek(0)
  341.             rv = buf.read(size)
  342.             self._rbuf = StringIO()
  343.             self._rbuf.write(buf.read())
  344.             return rv
  345.         self._rbuf = None()
  346.         while True:
  347.             left = size - buf_len
  348.             
  349.             try:
  350.                 data = self._sock.recv(left)
  351.             except error:
  352.                 e = None
  353.                 if e.args[0] == EINTR:
  354.                     continue
  355.                 raise 
  356.  
  357.             if not data:
  358.                 break
  359.             n = len(data)
  360.             if n == size and not buf_len:
  361.                 return data
  362.             if None == left:
  363.                 buf.write(data)
  364.                 del data
  365.                 break
  366.             if not n <= left:
  367.                 raise AssertionError('recv(%d) returned %d bytes' % (left, n))
  368.             None.write(data)
  369.             buf_len += n
  370.             del data
  371.         return buf.getvalue()
  372.  
  373.     
  374.     def readline(self, size = -1):
  375.         buf = self._rbuf
  376.         buf.seek(0, 2)
  377.         if buf.tell() > 0:
  378.             buf.seek(0)
  379.             bline = buf.readline(size)
  380.             if bline.endswith('\n') or len(bline) == size:
  381.                 self._rbuf = StringIO()
  382.                 self._rbuf.write(buf.read())
  383.                 return bline
  384.         if size < 0:
  385.             if self._rbufsize <= 1:
  386.                 buf.seek(0)
  387.                 buffers = [
  388.                     buf.read()]
  389.                 self._rbuf = StringIO()
  390.                 data = None
  391.                 recv = self._sock.recv
  392.                 while True:
  393.                     
  394.                     try:
  395.                         while data != '\n':
  396.                             data = recv(1)
  397.                             if not data:
  398.                                 break
  399.                             buffers.append(data)
  400.                     except error:
  401.                         e = None
  402.                         if e.args[0] == EINTR:
  403.                             continue
  404.                         raise 
  405.  
  406.                     break
  407.                 return ''.join(buffers)
  408.             None.seek(0, 2)
  409.             self._rbuf = StringIO()
  410.             while True:
  411.                 
  412.                 try:
  413.                     data = self._sock.recv(self._rbufsize)
  414.                 except error:
  415.                     e = None
  416.                     if e.args[0] == EINTR:
  417.                         continue
  418.                     raise 
  419.  
  420.                 if not data:
  421.                     break
  422.                 nl = data.find('\n')
  423.                 if nl >= 0:
  424.                     nl += 1
  425.                     buf.write(data[:nl])
  426.                     self._rbuf.write(data[nl:])
  427.                     del data
  428.                     break
  429.                 buf.write(data)
  430.             return buf.getvalue()
  431.         None.seek(0, 2)
  432.         buf_len = buf.tell()
  433.         if buf_len >= size:
  434.             buf.seek(0)
  435.             rv = buf.read(size)
  436.             self._rbuf = StringIO()
  437.             self._rbuf.write(buf.read())
  438.             return rv
  439.         self._rbuf = None()
  440.         while True:
  441.             
  442.             try:
  443.                 data = self._sock.recv(self._rbufsize)
  444.             except error:
  445.                 e = None
  446.                 if e.args[0] == EINTR:
  447.                     continue
  448.                 raise 
  449.  
  450.             if not data:
  451.                 break
  452.             left = size - buf_len
  453.             nl = data.find('\n', 0, left)
  454.             if nl >= 0:
  455.                 nl += 1
  456.                 self._rbuf.write(data[nl:])
  457.                 if buf_len:
  458.                     buf.write(data[:nl])
  459.                     break
  460.                 else:
  461.                     return data[:nl]
  462.             n = len(data)
  463.             if n == size and not buf_len:
  464.                 return data
  465.             if None >= left:
  466.                 buf.write(data[:left])
  467.                 self._rbuf.write(data[left:])
  468.                 break
  469.             buf.write(data)
  470.             buf_len += n
  471.         return buf.getvalue()
  472.  
  473.     
  474.     def readlines(self, sizehint = 0):
  475.         total = 0
  476.         list = []
  477.         while True:
  478.             line = self.readline()
  479.             if not line:
  480.                 break
  481.             list.append(line)
  482.             total += len(line)
  483.             if sizehint and total >= sizehint:
  484.                 break
  485.                 continue
  486.             return list
  487.  
  488.     
  489.     def __iter__(self):
  490.         return self
  491.  
  492.     
  493.     def next(self):
  494.         line = self.readline()
  495.         if not line:
  496.             raise StopIteration
  497.         return line
  498.  
  499.  
  500. _GLOBAL_DEFAULT_TIMEOUT = object()
  501.  
  502. def create_connection(address, timeout = _GLOBAL_DEFAULT_TIMEOUT, source_address = None):
  503.     """Connect to *address* and return the socket object.
  504.  
  505.     Convenience function.  Connect to *address* (a 2-tuple ``(host,
  506.     port)``) and return the socket object.  Passing the optional
  507.     *timeout* parameter will set the timeout on the socket instance
  508.     before attempting to connect.  If no *timeout* is supplied, the
  509.     global default timeout setting returned by :func:`getdefaulttimeout`
  510.     is used.  If *source_address* is set it must be a tuple of (host, port)
  511.     for the socket to bind as a source address before making the connection.
  512.     An host of '' or port 0 tells the OS to use the default.
  513.     """
  514.     (host, port) = address
  515.     err = None
  516.     for res in getaddrinfo(host, port, 0, SOCK_STREAM):
  517.         (af, socktype, proto, canonname, sa) = res
  518.         sock = None
  519.         
  520.         try:
  521.             sock = socket(af, socktype, proto)
  522.             if timeout is not _GLOBAL_DEFAULT_TIMEOUT:
  523.                 sock.settimeout(timeout)
  524.             if source_address:
  525.                 sock.bind(source_address)
  526.             sock.connect(sa)
  527.             return sock
  528.         continue
  529.         except error:
  530.             _ = None
  531.             err = _
  532.             if sock is not None:
  533.                 sock.close()
  534.             
  535.         
  536.  
  537.     
  538.     if err is not None:
  539.         raise err
  540.     raise error('getaddrinfo returns an empty list')
  541.  
  542.